/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 *
 */


/*
 * GUIPrincipal.java
 *
 * Created on 01-mar-2010, 22:50:42
 */
package interfaz;

import hilos.HiloModificaUcf;
import hilos.GestorHilos;
import hilos.HiloProceso;
import hilos.HiloInyeccion;
import IOFPGA.EntradaSalida;
import compiladorEntidad.Entidad;
import compiladorEntidad.Errores;
import compiladorEntidad.SintacticoEntidad;
import estructuras.Golden;
import estructuras.TestBench;
import generadorVHDL.GeneraVhdl_V5;
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Properties;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.*;
import javax.swing.filechooser.FileNameExtensionFilter;

/**
 * Frame principal de la aplicación
 * @author Rubén Tarancón y Felipe Serrano
 */
public class GUIPrincipal extends JFrame{
    
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////VARIABLES GLOBALES//////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    public final static String RUTA_NESSY = System.getProperties().getProperty("user.dir");
    public static String RUTA_ISE;
    public static String RUTA_EDK;
    public static String RUTA_PLANAHEAD;

    public static String RUTA_PROYECTO_ACTUAL;
    public static String RUTA_PROYECTO_ACTUAL_EDK;
    public static String RUTA_PROYECTO_ACTUAL_PLANAHEAD;
    public static String RUTA_PROYECTO_ACTUAL_SALIDAS;
    public static String RUTA_PROYECTO_ACTUAL_VHDL;

    //Variable que indica si es necesario o no, enviar el bitstream parcial
    // al hacer la reconfiguración parcial
    public static boolean parcialEnviado = false;
    
    //Semaforo global usado para sincronizar los procesos externos
    private GestorHilos gestor;

    //Variable global que indica cuantas transacciones seguidas
    // se pueden hacer hasta que se sincronize FPGA y PC
    private static int syncSerie = 10;

    private String ficheroEntidadVHD;
    private ArrayList<File> ficherosVHD;
    private ArrayList<String> stringsVHD;

    private TestBench fichero_tb;
    private Golden fichero_golden;
    public static File fichero_bit;
    public static File fichero_bit_parcial;

    //private final int MINX = 84, MAXX= 107, MINY=140, MAXY= 159;
    private final int MINX = 0, MAXX= 107, MINY=0, MAXY= 159;
    private int tamSliceX=0,tamSliceY=0;
    private int sliceXFinal, sliceYFinal;
    private int sliceXInicial,sliceYInicial;

    
    /**
     * Atributo para enviar y recibir datos por la entrada salida
     */
    private EntradaSalida entsal;
    /**
     * Representación interna de la entidad que se quiere ejecutar
     * tipoAdaptador puede valer 32, 64 o 128 en función del número de 
     * entradas necesarias
     */
    private Entidad entidad;
    private SintacticoEntidad compilador = null;
    private int tipoAdaptador;
    /**
     * Número de fichero que representa el top dentro del conjunto de ficheros
     */
    private int top;
    /**
     * Indica que el menú de selección top se ha cerrado
     */
    private boolean cerradoTop;  
    /**
     * Indica si se ha configurado por 1ª vez el puerto serie
     */
    boolean comConfigurado = false;
    
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////


    
    


    //////////////////////////////////////////////////////////////////////////
    /////////////////////////////CONSTRUCTORA/////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    public GUIPrincipal() {
        
        //Componentes de interfaz gráfica
        initComponentsAux();
        initComponents();
        
        //Gestor de procesos externos e hilos
        gestor = new GestorHilos();
        gestor.start();
        
        //Variables de Nessy
        stringsVHD = new ArrayList<>();
        this.ficherosVHD = new ArrayList<>();
        configurarNessy(RUTA_NESSY+"\\conf\\config.properties",false);
        
        String ruta = System.getProperty( "java.class.path" );
        ruta=ruta.substring(0, ruta.length()-12);
        new File(ruta+"conf").mkdir();
        
    }

    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    
    
    
    
    

    //////////////////////////////////////////////////////////////////////////
    //////////////////////METODOS MODIFICAR PARAMETROS ///////////////////////
    //////////////////////////////////////////////////////////////////////////
    /**
     * Devuelve el Array de ficheros Vhdl Cargados en la aplicación.
     * @return Valor del atributo ficherosVHD
     */
    public ArrayList<File> getFiles() {
        return ficherosVHD;
    }
    /**
     * Establece el fichero Top
     * @param top Índice del archivo TOP.
     */
    public void setTop(int top) {
        this.top = top;
    }
    /**
     * Devuelve el objeto EntradaSalida para comunicarse con el exterior
     */
    public EntradaSalida getEntradaSalida(){
        return entsal;
    }
    /**
     * Devuelve la Entidad con la que se está trabajado
     * @return Entidad con la que se está trabajando.
     */

    public Entidad getEntidad() {
        return entidad;
    }
    /**
     * Establece el campo cerradoTop, con el valor del argumento de la función.
     * @param cerradoTop Nuevo valor de tipo boolean de cerradoTop.
     */
    public void setCerradoTop(boolean cerradoTop) {
        this.cerradoTop = cerradoTop;
    }

    /**
     * @return String con la ruta donde se colocan los ficheros de salida de la aplicacion
     */
    public String getRutaSalidas(){
        return GUIPrincipal.RUTA_PROYECTO_ACTUAL_SALIDAS;
    }
    

    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    
    
    
    

    

    ////////////////////////////////////////////////////////////////////////////
    //////////////////////// METODOS CARGAR VHDL ///////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    /**
     * Carga varios ficheros VHDL de los cuales elegirá uno como top
     */
    private void cargaVariosVHDL() {
        JFileChooser chooser;
        this._TxtEntityVHD.setText("");
        chooser = new JFileChooser();
        chooser.setMultiSelectionEnabled(true);
        Filtro filter = new Filtro("vhd");
        chooser.addChoosableFileFilter(filter);
        chooser.setCurrentDirectory(new java.io.File("."));
        chooser.setDialogTitle("Seleccionar Archivos VHDL");
        chooser.setAcceptAllFileFilterUsed(false);
        if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
            ArrayList<String> ficheros = new ArrayList<>();
            File[] f = chooser.getSelectedFiles();
            ficherosVHD = new ArrayList<>();
            ficherosVHD.addAll(Arrays.asList(f));

            for (int i = 0; i < f.length; i++) {
                ficheros.add(f[i].getName());
            }
            cerradoTop = false;
            GUISeleccionTop selTop = new GUISeleccionTop(this, true, ficheros);
            selTop.setLocationRelativeTo(null);
            selTop.setVisible(true);
            if (!cerradoTop) {
                ficheroEntidadVHD = ficherosVHD.get(top).getAbsolutePath(); //el fichero es el absoluto
                this.cargarVHDL();
            }

        }
    }
    /**
     * Carga un fichero VHD como top
     */
    private void cargaTopVHDL() {
        JFileChooser chooser;
        chooser = new JFileChooser();
        Filtro filter = new Filtro("vhd");
        chooser.addChoosableFileFilter(filter);
        chooser.setCurrentDirectory(new java.io.File("."));
        chooser.setDialogTitle("Seleccionar Archivo VHDL");
        chooser.setAcceptAllFileFilterUsed(false);
        ficherosVHD = new ArrayList<>();
        if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
            ficherosVHD.add(chooser.getSelectedFile());
            ficheroEntidadVHD = ficherosVHD.get(0).getAbsolutePath();
            this.cargarVHDL();
        }
    }
    /**
     * Trata de compilar un fichero VHD y muestra un mensaje con lo
     * ocurrido en una ventana emergente
     */
    private void cargarVHDL() {
        boolean error = !compilarEntidad();
        if (!error) {
            seleccionaPanel(panelVHD);
            this._TxtEntityVHD.setText(this.entidad.toString());
        } else {
            JOptionPane.showMessageDialog(this, "Error al cargar el fichero de la entity", "Error", JOptionPane.ERROR_MESSAGE);
        }

    }
    /**
     * Compila la entidad y genera el archivo VHDL a partir de ella de tal forma
     * que se interconecte con el módulo de entrada/salida.
     * @return Cierto si todo ha sido correcto, falso si ha habido algún error.
     */
    public boolean compilarEntidad() {
        boolean correcto = true;
        int numMaxEntradas;
        Errores errores = new Errores();

        try {
            compilador = new SintacticoEntidad(ficheroEntidadVHD, errores);
            compilador.inicia();

            boolean error = compilador.Entidad();
            if (!error) {
                this.entidad = compilador.getEntidad();
                numMaxEntradas = Math.max(entidad.getBitsEntrada(), entidad.getBitsSalida());
                if(numMaxEntradas<=32){
                    tipoAdaptador=32;
                }else if(numMaxEntradas<=64){
                    tipoAdaptador=64;
                }else{
                    JOptionPane.showMessageDialog(this, "El número de entradas/salidas "
                    + "del circuito es demasiado grande", "Error", JOptionPane.ERROR_MESSAGE);
                    correcto=false;
                }
            } else {
                this.muestraErroresConsola(errores);
                correcto = false;
            }
        } catch (Exception e) {
            if (e.getMessage() != null) {
                errores.error(e.getMessage());
                this.muestraErroresConsola(errores);
            }
            correcto = false;

        }
        if (compilador != null) {
            compilador.cerrar();
        }
        return correcto;
    }
    /**
     * Muestra los errores obtenidos en el proceso de compilación de la entidad
     * por la pestaña de EntityVHD.
     * @param errores
     */
    private void muestraErroresConsola(Errores errores) {
        this._TxtEntityVHD.setText("");
        for (int i = 0; i < errores.getErrores().size(); i++) {
            this._TxtEntityVHD.append(errores.getErrores().get(i) + "\n");
        }
    }
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////




    ////////////////////////////////////////////////////////////////////////////
    //////////////////////// METODOS CREAR .BIT ////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    private boolean crearBit() throws Exception{
        boolean correcto = true;

        seleccionaPanel(panelCrearBit);
        this._TextCrearBit.setText(null);

       
        obtenerRegionCircuito();

        //Comprobamos si existe el archivo bitstream para ahorrarnos el paso de síntesis
        File download = new File(RUTA_PROYECTO_ACTUAL+"\\download.bit");
        if(!download.exists()){
            //Copia los archivos EDK
            
            _TextCrearBit.append("Creando proyecto EDK...............");
            if(!copiarArchivos()){
                _TextCrearBit.append("ERROR\n");
                JOptionPane.showMessageDialog(this, "No se ha podido copiar el Proyecto_EDK plantilla", "Error", JOptionPane.ERROR_MESSAGE);
                return false;
            }
            _TextCrearBit.append("OK\n");
            
            //Generamos el archivo circuito.vhd
            _TextCrearBit.append("Adaptando el proyecto EDK..........");
            if(!generarVhdl()){
                _TextCrearBit.append("ERROR\n");
                JOptionPane.showMessageDialog(this, "No se ha podido generar el vhdl necesario para adaptar el proyecto EDK", "Error", JOptionPane.ERROR_MESSAGE);
                return false;
            }
            _TextCrearBit.append("OK\n");

            //Modificamos el .mpd del pcore circuito
            _TextCrearBit.append("Modificando el archivo .mpd........");
            if(!modificaMpd())
                {
                _TextCrearBit.append("ERROR\n");
                JOptionPane.showMessageDialog(this, "No se ha podido modificar el .mpd", "Error", JOptionPane.ERROR_MESSAGE);
                return false;
                }
            _TextCrearBit.append("OK\n");
            
            
            //Modificamos el .pao del pcore circuito
            _TextCrearBit.append("Modificando el archivo .pao........");
            if(!modificaPao())
                {
                this._TextCrearBit.append("ERROR\n");
                JOptionPane.showMessageDialog(this, "No se ha podido modificar el .pao", "Error", JOptionPane.ERROR_MESSAGE);
                return false;
                }
            _TextCrearBit.append("OK\n");

            //***************************PROCESOS EXTERNOS********************//
            //Generamos el netlist con el EDK
            compilarProyectoEDK();

            //Modificar el .ucf generado por el EDK para el planahead
            modificaUcf();
            
            //Generamos el .bit  y el bitstream parcial con el planahead
            compilarProyectoPlanAhead();

            //Copiar bitstream parcial a la carpeta base del proyecto
            copiarBitstreamParcial();
        }

        //Creamos el bitstream final con el software mapeado
        data2mem();
        //********************************************************************//
        return correcto;
    }
    
    /**
     * Pide al usuario las coordenadas de la región donde se instanciará
     * el circuito
     * @return false si no se ha podido modificar el fichero del proyecto
     */
    private boolean obtenerRegionCircuito(){
         //Obtenemos el tamaño a reservar para el circuito del usuario
        //y lo escribimos en el archivo del proyecto
        boolean restriccionesSlices = false; 
        boolean correcto = true;
        restriccionesSlices = tamSliceX>0 && tamSliceY>0 &&
                    sliceXInicial >= MINX && sliceXInicial <= MAXX && sliceYInicial >= MINY && sliceYInicial <= MAXY &&
                    sliceXFinal >= MINX && sliceXFinal <= MAXX && sliceYFinal >= MINY && sliceYFinal <= MAXY;
        
        //Se itera hasta que no se introduzcan unas coordenadas válidas 
        while(!restriccionesSlices){
            int limites[] = {MINX,MINY,MAXX,MAXY};
            GUIInyeccionErrores GuiInyeccionErrores = new GUIInyeccionErrores(this, correcto, limites);
            GuiInyeccionErrores.setLocationRelativeTo(null);
            GuiInyeccionErrores.setVisible(true);
            sliceXInicial = GuiInyeccionErrores.getXInicial();
            sliceYInicial = GuiInyeccionErrores.getYInicial();
            sliceXFinal = GuiInyeccionErrores.getXFinal();
            sliceYFinal = GuiInyeccionErrores.getYFinal();
            tamSliceX = sliceXFinal - sliceXInicial;
            tamSliceY = sliceYFinal - sliceYInicial;
            restriccionesSlices = tamSliceX>=0 && tamSliceY>=0 &&
                    sliceXInicial >= MINX && sliceXInicial <= MAXX && sliceYInicial >= MINY && sliceYInicial <= MAXY &&
                    sliceXFinal >= MINX && sliceXFinal <= MAXX && sliceYFinal >= MINY && sliceYFinal <= MAXY;
            
            //Si las coordenadas son válidas, se actualiza el fichero del proyecto
            if(restriccionesSlices){
                BufferedWriter bw = null;
                try {
                    bw = new BufferedWriter(new FileWriter(RUTA_PROYECTO_ACTUAL+"\\Proyecto.nessy",true));
                    bw.write(String.valueOf(sliceXInicial)+"\n");
                    bw.write(String.valueOf(sliceYInicial)+"\n");
                    bw.write(String.valueOf(sliceXFinal)+"\n");
                    bw.write(String.valueOf(sliceYFinal)+"\n");
                    bw.close();
                } catch (IOException ex) {
                    return false;
                }
            }
        }
        return true;
    }
   
    private boolean copiarArchivos() throws Exception{
        //Se copia todo el proyecto EDK base a la carpeta del proyecto excepto por el adaptador_circuito
        Process proc_proyecto = Runtime.getRuntime().exec("xcopy.exe /Y /E /Q "+"\""+RUTA_NESSY+"\\Proyecto_EDK_V5\" \"" + RUTA_PROYECTO_ACTUAL_EDK+"\"");
        proc_proyecto.waitFor();
        if(proc_proyecto.exitValue() != 0){
            return false;
        }
        
        //Se copia el adaptador_circuito que corresponda a la carpeta del proyecto
        String carpetaAdaptador;
        if(tipoAdaptador==32){
            carpetaAdaptador="adaptador_circuito_32_v1_00_a";
        }else if(tipoAdaptador==64){
            carpetaAdaptador="adaptador_circuito_64_v1_00_a";
        }else{
            return false;
        }

        Process proc_adaptador = Runtime.getRuntime().exec("xcopy.exe /Y /E /Q " + "\""+RUTA_NESSY+"\\Adaptadores_circuito\\"+carpetaAdaptador+"\" \"" + RUTA_PROYECTO_ACTUAL_EDK+"\\pcores\\adaptador_circuito_v1_00_a\\\"");
        proc_adaptador.waitFor();
        if(proc_adaptador.exitValue() != 0){
            return false;
        }
        
        
        //Se copian los vhdl fuentes a la carpeta del proyecto
        Process proc_archivo = Runtime.getRuntime().exec("xcopy /Y /Q \""+RUTA_PROYECTO_ACTUAL_VHDL+"\" \""+RUTA_PROYECTO_ACTUAL_EDK+"\\pcores\\circuito_v1_00_a\\hdl\\vhdl\\\"");
        proc_archivo.waitFor();
        if(proc_archivo.exitValue() != 0){
            return false;
        }


        return true;
    }
     /**
     * Crea el fichero user_logic integrando la interfaz con el bus con el circuito
     */

    private boolean generarVhdl() throws Exception{
        Errores errores = new Errores();
        GeneraVhdl_V5 generador;

        generador = new GeneraVhdl_V5(RUTA_PROYECTO_ACTUAL_EDK+"\\pcores\\circuito_v1_00_a\\hdl\\vhdl\\circuito.vhd", compilador.getEntidad(), tipoAdaptador, errores);
        if (generador.abrir()) {
            generador.crearFichero();
            generador.cerrar();
            return true;
        } else {
            this.muestraErroresConsola(errores);
            return false;
        }
    }
    
    /**
     * Completa el archivo .mpd del pcore circuito añadiendo el tamaño que éste
     * tendrá una vez parseado la entidad vhdl
     */
    private boolean modificaMpd(){
        BufferedWriter bw;
        int numMaxBits = tipoAdaptador-1;
        try{
            bw = new BufferedWriter(new FileWriter(RUTA_PROYECTO_ACTUAL_EDK+"\\pcores\\circuito_v1_00_a\\data\\circuito_v2_1_0.mpd",true));
            bw.write("PORT entrada_circuito = \"\", DIR = I, VEC = [0:"+numMaxBits+"]\n"+
                     "PORT salida_circuito = \"\", DIR = O, VEC = [0:"+numMaxBits+"]\n"+
                     "\n"+
                     "END");
            bw.close(); 
        }catch(IOException e){
            return false;
        }
        return true;
    }
    
    /**
     * Modifica el fichero .pao del proyecto de EDK , concretamente el creado en
     * pcores/adaptador_circuito/data hay que añadir todos los ficheros que hemos
     * introducido desde el nessy
     */
    private boolean modificaPao(){
        BufferedWriter bw;
        try{
            bw = new BufferedWriter(new FileWriter(RUTA_PROYECTO_ACTUAL_EDK+"\\pcores\\circuito_v1_00_a\\data\\circuito_v2_1_0.pao",true));
            for(int i=0;i<stringsVHD.size();i++){
                String fichero = stringsVHD.get(i);
                fichero = fichero.substring(fichero.lastIndexOf('\\')+1,fichero.lastIndexOf('.'));
                bw.write("\nlib circuito_v1_00_a "+fichero+" vhdl");
            }
            bw.close(); 
        }catch(IOException e){
            return false;
        }
        return true;
    }    
    
    private void compilarProyectoEDK(){
        String comando = RUTA_EDK+"\\bin\\nt\\xps.exe -nw -scr "+RUTA_NESSY+"\\comandosEDK\\netlist.tcl "+RUTA_PROYECTO_ACTUAL_EDK+"\\system.xmp";
        String salida = RUTA_PROYECTO_ACTUAL_SALIDAS+"\\EDK.log";
        HiloProceso bitstream = new HiloProceso("Edk", _TextCrearBit,comando,salida);
        gestor.encolarHilo(bitstream);
    }
    
    private void modificaUcf() {
        HiloModificaUcf modificaUcf = new HiloModificaUcf("ModificaUcf");
        gestor.encolarHilo(modificaUcf);
    }

    public void compilarProyectoPlanAhead(){
        crearScriptPlanahead();
        String comando = RUTA_PLANAHEAD+"\\bin\\planAhead.bat -mode batch -source ./comandosEDK/generar_bit_parciales.tcl" ;
        String salida = RUTA_PROYECTO_ACTUAL_SALIDAS+"\\Planahead.log";
        HiloProceso bitstreams = new HiloProceso("Planahead", _TextCrearBit,comando,salida);
        gestor.encolarHilo(bitstreams);
    }

    public void data2mem(){
        String comando3= RUTA_ISE+"\\bin\\nt\\data2mem.exe -bm " + RUTA_PROYECTO_ACTUAL_EDK + "\\implementation\\system_bd.bmm " +
                                  "-bt " + RUTA_PROYECTO_ACTUAL_PLANAHEAD + "\\planahead.runs\\config_nessy\\config_nessy.bit "+
                                  "-bd " + RUTA_PROYECTO_ACTUAL_EDK + "\\SDK\\SDK_Workspace_35\\Nessy\\Debug\\Nessy.elf "+
                                  "tag microblaze_0 -o b "+RUTA_PROYECTO_ACTUAL+"\\download.bit";
        String salida3 = RUTA_PROYECTO_ACTUAL_SALIDAS+"\\Data2mem.log";
        ArrayList<JButton> lstBotones = new ArrayList<>();
        lstBotones.add(_btnCargarBit);
        HiloProceso data2mem = new HiloProceso("Data2mem", _TextCrearBit,comando3,salida3,lstBotones);
        gestor.encolarHilo(data2mem);
    }
    
    public void copiarBitstreamParcial(){
        String comando4 = "xcopy /Y /Q \""+RUTA_PROYECTO_ACTUAL_PLANAHEAD+"\\planahead.runs\\config_nessy\\config_nessy_circuito_0_circuito_reconfig_partial.bit"+"\" \""+RUTA_PROYECTO_ACTUAL+"\\\"";
        HiloProceso copiar_bitstream = new HiloProceso("Copiar bitstream",_TextCrearBit,comando4,null);
        gestor.encolarHilo(copiar_bitstream);
    }

    public void crearScriptPlanahead(){
        try {
            BufferedWriter bw;
            bw = new BufferedWriter(new FileWriter(RUTA_NESSY + "\\comandosEDK\\generar_bit_parciales.tcl", false));
            bw.write("create_project -part xc5vlx110tff1136-1 -force planahead {" + RUTA_PROYECTO_ACTUAL_PLANAHEAD + "}\n");
            bw.write("set_property design_mode GateLvl [get_property srcset [current_run]]\n");
            bw.write("set_property edif_top_file {" + RUTA_PROYECTO_ACTUAL_EDK + "\\implementation\\system.ngc} [get_property srcset [current_run]]\n");
            bw.write("import_files -force -norecurse {" + RUTA_PROYECTO_ACTUAL_EDK + "\\implementation}\n");
            bw.write("add_files -fileset [get_property constrset [current_run]] -norecurse {" + RUTA_PROYECTO_ACTUAL_EDK + "\\data\\system.ucf}\n");
            bw.write("set_property name config_1 [current_run]\n");
            bw.write("set_property is_partial_reconfig true [current_project]\n");
            bw.write("open_netlist_design -name netlist_1\n");
            bw.write("add_reconfig_module -name circuito_reconfig -cell {circuito_0}\n");
            bw.write("resize_pblock pblock_circuito_0 -add {SLICE_X"+sliceXInicial+"Y"+sliceYInicial+":SLICE_X"+sliceXFinal+"Y"+sliceYFinal+"} -locs keep_all -replace\n");
            bw.write("set_property name config_nessy [get_runs config_1]\n");
            bw.write("set_property strategy \"ISE Defaults\" [get_runs config_nessy]\n");
            bw.write("set_property  gridtypes {DSP48 SLICE} [get_pblocks pblock_circuito_0]\n");
            bw.write("config_run -run config_nessy -program ngdbuild -option -bm -value {" + RUTA_PROYECTO_ACTUAL_EDK + "\\implementation\\system.bmm}\n");
            bw.write("save_design\n");
            bw.write("launch_runs -runs config_nessy -jobs 1 -dir {" + RUTA_PROYECTO_ACTUAL_PLANAHEAD + "\\planahead.runs}\n\n\n");
            bw.write("wait_on_run config_nessy\n");
            bw.write("promote_run -run {config_nessy} -partition_names {  {system} {circuito_0} }\n");
            bw.write("set_property add_step Bitgen [get_runs config_nessy]\n");
            bw.write("launch_runs -runs config_nessy -jobs 1 -dir {" + RUTA_PROYECTO_ACTUAL_PLANAHEAD + "\\planahead.runs}\n");
            bw.write("wait_on_run config_nessy\n");
            bw.write("exit\n");
            bw.close();
        } catch (IOException ex) {
            Logger.getLogger(GUIPrincipal.class.getName()).log(Level.SEVERE, null, ex);
        }
}


    private void copiarLog() throws Exception{
        BufferedReader br = new BufferedReader(new FileReader(RUTA_PROYECTO_ACTUAL_SALIDAS+"\\EDK.log"));
        String linea = br.readLine();
        while(linea != null){
            _TextCrearBit.append(linea+"\n");
            linea = br.readLine();
        }
        br.close();
    }
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////


    


    ////////////////////////////////////////////////////////////////////////////
    //////////////////////// METODOS CARGAR .BIT ///////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    /**
     * Carga un fichero .BIT utilizando la interfaz de carga. Realiza 6 intentos
     * de carga por hubiera algún error ajeno a la aplicación que impidiera
     * su carga. Si no estamos en el proceso de reconfiguración parcial, se
     * mostrará un mensaje indicando que la carga del bitstream se ha producido
     * correctamente.
     * @param fichero_bit El fichero a cargar
     * @param ab_mostrar_mensajes Indica si hay que mostrar mensajes de
     * información de lo ocurrido.
     * @return true si ha sido correcta la ejecucion y false en caso contrario
     */
    public boolean cargarBit(String fichero_bit) {
        seleccionaPanel(panelCargar);
        _TextCargarbit.setText(null);
        descargarBitstream(fichero_bit);
        return true;
    }

    public void descargarBitstream(String fichero_bit){
        crearScriptImpact(fichero_bit);
        String comando = "\""+GUIPrincipal.RUTA_ISE + "\\bin\\nt\\impact.exe\"" + " -batch \"" + RUTA_PROYECTO_ACTUAL_SALIDAS + "\\cargaBit.cmd\"";
        String salida = RUTA_PROYECTO_ACTUAL_SALIDAS + "\\impact.txt";
        ArrayList<JButton> lstBotones = new ArrayList<>();
        lstBotones.add(_btnCargarTB);
        HiloProceso impact = new HiloProceso("Impact",_TextCargarbit,comando,salida,lstBotones);
        gestor.encolarHilo(impact);
    }

    public void crearScriptImpact(String fichero_bit){
        FileOutputStream os;
        try {
            os = new FileOutputStream(RUTA_PROYECTO_ACTUAL_SALIDAS + "\\cargaBit.cmd");
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
            String coms = "setMode -bscan \n" + "setCable -p auto\n" + "identify\n" + "identifyMPM\n" + "assignfile -p 5 -file \"" + fichero_bit + "\"\n" + "program -p 5\n" + "quit";
            bw.write(coms);
            bw.close();
        } catch (IOException ex) {
            Logger.getLogger(GUIPrincipal.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    /**
     * Comprueba si existe o no un fichero.
     * @param ruta Cadena de la ruta del fichero
     * @return Boolean,cierto si existe el fichero falso en caso contrario.
     */
    public boolean existeFichero(String ruta) {
        File fichero = new File(ruta);
        return fichero.exists();
    }
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    
    
    
    

    ////////////////////////////////////////////////////////////////////////////
    //////////////////////// METODOS EJECUTAR //////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    public boolean ejecutar() throws Exception{
        String datoCircuito, datoGolden;
        
        this.seleccionaPanel(panelOutput);
        _TextEjecucion.setText("");

        if(!entsal.comprobarComunicacion()) return false;
        
        //Comando ejecutar enviando resultado
        entsal.enviarBinaria(9);
        _TextEjecucion.append("\tSalida / Golden\n");
        for (int i = 0; i < fichero_tb.getNumEntradasTB(); i++) {
            if ((i % syncSerie) == 0) entsal.esperarPalabraSyn();
            datoCircuito = entsal.recibirEntradaTB(entidad.getBitsSalida());
            datoGolden = fichero_golden.getEntradaTB(i);
            _TextEjecucion.append(i + ":\t" + datoCircuito + " / " + datoGolden);
            if (datoGolden.equals(datoCircuito)) {
                _TextEjecucion.append("\tOK\n");
            } else {
                _TextEjecucion.append("\tERROR\n");
            }
            _TextEjecucion.setCaretPosition(_TextEjecucion.getText().length());
        }
        return true;
    }
    
    
    
    /**
     * Nos devuelve un String diciendo la posicion del String donde hay 1's
     */
    public String erroresString(String s) {
        String r="";
        int i;
        for(i=0;i<s.length();i++){
            if (s.charAt(i) == '1'){
                if(i<s.length()-1){
                    r = r + i+ ", ";
                }else{
                    r = r + i;
                }
            }
        }
        return r;
    }
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    
    

    

    ////////////////////////////////////////////////////////////////////////////
    //////////////////////// METODOS CARGAR TESTBENCH //////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    
    public boolean cargarTB(){
        if (entsal == null) {
            boolean ret = true;
            GUIComConfig GUIcom = new GUIComConfig(this, ret);
            GUIcom.setLocationRelativeTo(null);
            GUIcom.setVisible(true);

            ret = configurarPuertoSerie(GUIcom.getSel());
            if (!ret) {
                JOptionPane.showMessageDialog(this, "Error al abrir el puerto " + GUIcom.getSel(), "Error", JOptionPane.ERROR_MESSAGE);
                entsal = null;
            }
        }

        if (!entsal.comprobarComunicacion()) {
            JOptionPane.showMessageDialog(this, "Error en la comunicación con el puerto serie", "Error", JOptionPane.ERROR_MESSAGE);
            return false;
        }
        if (fichero_tb == null && !seleccionarTB()) {
            fichero_tb = null;
            JOptionPane.showMessageDialog(this, "Error al seleccionar el testbench", "Error", JOptionPane.ERROR_MESSAGE);
            return false;
        }
        if (!enviarTB()) {
            JOptionPane.showMessageDialog(this, "Error al leer el testbench", "Error", JOptionPane.ERROR_MESSAGE);
            _TextTB.setText("");
            return false;
        }
        return true;
    }

    private boolean seleccionarTB() {
        JFileChooser chooser;

        this._TextTB.setText("");
        chooser = new JFileChooser();
        Filtro filter = new Filtro("txt");
        chooser.addChoosableFileFilter(filter);
        chooser.setCurrentDirectory(new java.io.File("."));
        chooser.setDialogTitle("Seleccionar TestBench");
        chooser.setAcceptAllFileFilterUsed(false);

        if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
            fichero_tb = new TestBench(chooser.getSelectedFile().getAbsolutePath());
            if(!fichero_tb.leerTB()) return false;
            return true;
        }else{
            return false;
        }
    }

    public boolean enviarTB(){
        int numEntradasTB;
        String entradaTB;
        String comando, numLineasStr, palabrasPorEntradaTB;
        
            seleccionaPanel(panelTB);
            _TextTB.setText("");
            
            //Comando enviar testbench junto con el tamaño de este y cuantas
            //palabras de 32 bits es una entrada de TB
            numEntradasTB = fichero_tb.getNumEntradasTB();
            entsal.enviarBinaria(0);
            entsal.enviarBinaria(numEntradasTB);
            entsal.enviarBinaria(tipoAdaptador/32);
            
            //Envio del testbench
            for (int i = 0; i < numEntradasTB; i++) {
                entradaTB = fichero_tb.getEntradaTB(i);
                if ((i % syncSerie) == 0) entsal.esperarPalabraSyn();
                entsal.enviarEntradaTB(entradaTB);
            }
            
            //Recibo el testbench para comprobar que se envió bien
            entsal.enviarBinaria(8);
            for (int i = 0; i < numEntradasTB; i++) {
                if ((i % syncSerie) == 0) entsal.esperarPalabraSyn();
                entradaTB = entsal.recibirEntradaTB(entidad.getBitsEntrada());
                this._TextTB.append(i + ": \t" + entradaTB + "\n");
                this._TextTB.setCaretPosition(_TextTB.getText().length());
            }
        return true;
    }
    
    

    
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    
    

    


    ////////////////////////////////////////////////////////////////////////////
    //////////////////////// METODOS GENERAR GOLDEN ////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    public boolean generarGolden() {
        String salidaTB;
        BufferedWriter bw;
        int i;

        if (!entsal.comprobarComunicacion()) {
            JOptionPane.showMessageDialog(this, "Error en la comunicación", "Error", JOptionPane.ERROR_MESSAGE);
            return false;
        }

        seleccionaPanel(panelGolden);
        _TextGolden.setText(null);
        
        //Fichero golden
        fichero_golden = new Golden(RUTA_PROYECTO_ACTUAL_SALIDAS + "\\golden.txt",entidad.getBitsSalida());
        
        //Comandos de generar golden y recibir golden
        entsal.enviarBinaria(1);
        entsal.esperarPalabraSyn();
        entsal.enviarBinaria(3);
        
        //Escribe los datos del golden en el fichero y en la pestaña de la interfaz
        fichero_golden.abrirGolden();
        for (i = 0; i < fichero_tb.getNumEntradasTB(); i++) {
            if ((i % syncSerie) == 0) entsal.esperarPalabraSyn();
            salidaTB = entsal.recibirEntradaTB(entidad.getBitsSalida());
            if (salidaTB == null) {
                fichero_golden = null;
                return false;
            }
            fichero_golden.addEntradaGolden(salidaTB);
            _TextGolden.append(i + ": \t" + salidaTB + "\n");
            _TextGolden.setCaretPosition(_TextGolden.getText().length());
        }
        fichero_golden.cerrarGolden();

        return true;
    }
    
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    



    ////////////////////////////////////////////////////////////////////////////
    //////////////////////// METODOS CARGAR GOLDEN ////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    private boolean cargarGolden(){
        JFileChooser chooser;

        if(!entsal.comprobarComunicacion()) return false;
        chooser = new JFileChooser();
        Filtro filter = new Filtro("txt");
        chooser.addChoosableFileFilter(filter);
        chooser.setCurrentDirectory(new java.io.File("."));
        chooser.setDialogTitle("Seleccionar Archivo Golden");
        chooser.setAcceptAllFileFilterUsed(false);
        if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
            fichero_golden = new Golden(chooser.getSelectedFile().getAbsolutePath(),entidad.getBitsSalida());
            if(!fichero_golden.leerTB()) return false;
            if(fichero_golden.getNumEntradasTB() != fichero_tb.getNumEntradasTB()) return false;
            if(!enviarGolden()) return false;
            return true;
        }else{
            fichero_golden = null;
            return false;
        }
    }
    
    
    public boolean enviarGolden() {
        String entradaGolden;
        int numEntradasGolden;
        
        numEntradasGolden = fichero_golden.getNumEntradasTB();
        seleccionaPanel(panelGolden);
        _TextGolden.setText(null);
        
        //Comando
        entsal.enviarBinaria(4);
        //Envio del golden
        for (int i = 0; i < fichero_golden.getNumEntradasTB(); i++) {
            if ((i % syncSerie) == 0) {
                entsal.esperarPalabraSyn();
            }
            entradaGolden = fichero_golden.getEntradaTB(i);
            this._TextGolden.append(i + ": \t" + entradaGolden.substring(0, entidad.getBitsSalida()) + "\n");
            entsal.enviarEntradaTB(entradaGolden);
        }

        return true;
    }
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////





    ////////////////////////////////////////////////////////////////////////////
    //////////////////////// METODOS RECONFIGURACION //////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    public boolean reconfiguracion() {
        seleccionaPanel(panelErroresReconfiguracion);
        _TextErroresReconfiguracion.setText(null);
        if (fichero_bit.exists()) {
            if (!entsal.comprobarComunicacion()) return false;
            //Enviar el .bit por la entrada serie para escribirlo en ram y a continuación empezar con la inyección de errores
            HiloInyeccion inyeccion = new HiloInyeccion("Reconfiguración", _TextErroresReconfiguracion, entsal);
            gestor.encolarHilo(inyeccion);

        } else {
            return false;
        }
        return true;
    }

    //Calcula el tamaño, en palabras de 32 bits, del bitstream pasado
    public static int tamaño32bits(File f) {
        int tam32;
        long tam;
        tam = f.length();
        if (tam % 4 == 0) {
            tam32 = (int) (tam / 4);
        } else {
            tam32 = (int) (tam / 4) + 1;
        }
        return tam32;
    }


    public static String intToBinario8(int n){
        String binaria = Integer.toBinaryString(n);
        int l = binaria.length();
        for(int i=l;i<8;i++){
            binaria = '0'+binaria;
        }
        return binaria;
    }
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////

    
    
    

    ////////////////////////////////////////////////////////////////////////////
    //////////////////////// METODOS CONFIGURACION /////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    /**
     * Vuelve a cargar la configuracón de la aplicación
     * @param fichConf El fichero de configuración
     * @param cargaFich Indica si hay que carga desde fichero
     */
    private void configurarNessy(String fichConf, boolean cargaFich) {
        Properties prop = new Properties();
        InputStream is;
        String proyectoDefecto;
        String comDefecto;
        String reconfiguracionAutomatica="";
        String testbenchDefecto;
        
        boolean error=false; 
        boolean proyectoAbierto=false;
        
        try {
            is = new FileInputStream(fichConf);
            prop.load(is);

            //CONFIGURACIÓN DEL SOFTWARE DE XILINX
            RUTA_ISE = prop.getProperty("HomeXilinxISE");
            RUTA_EDK = prop.getProperty("HomeXilinxEDK");
            RUTA_PLANAHEAD = prop.getProperty("HomeXilinxPLANAHEAD");
            if (cargaFich) {
                if (RUTA_ISE == null || RUTA_ISE.equals("") || RUTA_EDK == null || RUTA_EDK.equals("") || RUTA_PLANAHEAD == null || RUTA_PLANAHEAD.equals("")) {
                    JOptionPane.showMessageDialog(this, ""
                            + "El fichero de configuración seleccionado "
                            + "no es valido", "Info", JOptionPane.INFORMATION_MESSAGE);
                }
            } else {
                boolean cierre=false;
                while ((RUTA_ISE == null || RUTA_ISE.equals("") || RUTA_EDK == null || RUTA_EDK.equals("")|| RUTA_PLANAHEAD == null || RUTA_PLANAHEAD.equals(""))&& !cierre) {
                    GUIConfig config = new GUIConfig(this, true, "","", "");
                    config.setVisible(true);
                    is = new FileInputStream(fichConf);
                    prop.load(is);
                    RUTA_ISE = prop.getProperty("HomeXilinxISE");
                    RUTA_EDK = prop.getProperty("HomeXilinxEDK");
                    RUTA_PLANAHEAD = prop.getProperty("HomeXilinxPLANAHEAD");
                    cierre=config.getCierre();
                }
            }
            
            //BÚSQUEDA DEL ÚLTIMO PROYECTO ABIERTO
            proyectoDefecto = prop.getProperty("ProyectoDefecto");
            if(proyectoDefecto != null){
                error = proyectoAbrir(proyectoDefecto);
                if(error){
                    JOptionPane.showMessageDialog(this, ""
                            + "No se ha podido abrir el proyecto por defecto "+proyectoDefecto+".\n "
                            + "Comprobar en /conf/config.properties", "Aviso", JOptionPane.WARNING_MESSAGE);
                }else{
                    proyectoAbierto=true;
                }
            }

            
            //RECONFIGURACIÓN DE LA FPGA
            reconfiguracionAutomatica = prop.getProperty("ReconfiguracionAutomatica");
            if(!error && proyectoAbierto && reconfiguracionAutomatica != null && fichero_bit != null){
                if(reconfiguracionAutomatica.equals("SI") && fichero_bit.exists()){
                    error = !cargarBit(fichero_bit.toString());
                }
            }

            //CONFIGURACIÓN DEL PUERTO SERIE
            comDefecto=prop.getProperty("ComDefecto");
            if(!error && comDefecto != null){
                error = !configurarPuertoSerie(comDefecto);
            }
            
            //CARGA DEL TESTBENCH
            testbenchDefecto=prop.getProperty("TestbenchDefecto");
            if(!error && testbenchDefecto != null){
                fichero_tb = new TestBench(testbenchDefecto);
                if(!fichero_tb.leerTB()){
                    fichero_tb = null;
                    JOptionPane.showMessageDialog(this, ""
                            + "No se ha podido leer el testbench por defecto", "Aviso", JOptionPane.WARNING_MESSAGE);
                }
            }

        } catch (IOException e) {
             JOptionPane.showMessageDialog(this, "No ha sido posible configurar" +
                     " nessy, debido a que no se ha encontrado archivo de " +
                     "configuración, para poder ejecutar Nessy correctamente" +
                     " acceda a configuración.", "Info", JOptionPane.INFORMATION_MESSAGE);
        }

    }

    /*
     * Procedimiento para cambiar la ruta de barras \ a barras /
     */
    public String cambiarRuta(String ruta){
        String s;
        s=ruta.replace('\\', '/');
        return s;
    }
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    
    



    ////////////////////////////////////////////////////////////////////////////
    ///////////////////////////// OTROS METODOS ////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////

    private void deshabilitarBotones(boolean b) {
        _btnCargarBit.setEnabled(!b);
        _btnCargarGolden.setEnabled(!b);
        _btnCargarTB.setEnabled(!b);
        _btnCargarVhd.setEnabled(!b);
        _btnCrearBit.setEnabled(!b);
        _btnEjecutar.setEnabled(!b);
        _btnGenerarGolden.setEnabled(!b);
        _btnReconfiguracion.setEnabled(!b);
    }
    /**
     * Selecciona uno de las cuatro pestañas según lo pasado por parámetro
     * @param panel Panel al que se quiere cambiar
     */
public void seleccionaPanel(JPanel panel) {
    try {
        if ((Boolean) ((JTabbedPaneWithCloseIcon) jTabbedPane1).getTablaPaneles().get(panel)) {
            jTabbedPane1.setSelectedComponent(panel);
        } else {
            if (panel.getName().equals(panelOutput)) {
                _TextEjecucion.setColumns(20);
                _TextEjecucion.setEditable(false);
                _TextEjecucion.setRows(5);
                jScrollPane4.setViewportView(_TextEjecucion);

                javax.swing.GroupLayout panelOutPutLayout = new javax.swing.GroupLayout(panelOutput);
                panelCrearBit.setLayout(panelOutPutLayout);
                panelOutPutLayout.setHorizontalGroup(
                        panelOutPutLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addComponent(jScrollPane4, javax.swing.GroupLayout.DEFAULT_SIZE, 715, Short.MAX_VALUE));
                panelOutPutLayout.setVerticalGroup(
                        panelOutPutLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addComponent(jScrollPane4, javax.swing.GroupLayout.DEFAULT_SIZE, 297, Short.MAX_VALUE));

                jTabbedPane1.addTab("Golden", panelOutput);
                jTabbedPane1.setSelectedComponent(panelOutput);
            } else if (panel.getName().equals(panelCrearBit)) {
                _TextCrearBit.setColumns(20);
                _TextCrearBit.setEditable(false);
                _TextCrearBit.setRows(5);
                jScrollPane4.setViewportView(_TextCrearBit);

                javax.swing.GroupLayout panelOutPutLayout = new javax.swing.GroupLayout(panelCrearBit);
                panelCrearBit.setLayout(panelOutPutLayout);
                panelOutPutLayout.setHorizontalGroup(
                        panelOutPutLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addComponent(jScrollPane4, javax.swing.GroupLayout.DEFAULT_SIZE, 715, Short.MAX_VALUE));
                panelOutPutLayout.setVerticalGroup(
                        panelOutPutLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addComponent(jScrollPane4, javax.swing.GroupLayout.DEFAULT_SIZE, 297, Short.MAX_VALUE));

                jTabbedPane1.addTab("Crear bit", panelCrearBit);
                jTabbedPane1.setSelectedComponent(panelCrearBit);
            } else if (panel.getName().equals(panelCargar)) {
                _TextCargarbit.setColumns(20);
                _TextCargarbit.setEditable(false);
                _TextCargarbit.setRows(5);
                jScrollPane4.setViewportView(_TextCargarbit);

                javax.swing.GroupLayout panelOutPutLayout = new javax.swing.GroupLayout(panelCargar);
                panelCrearBit.setLayout(panelOutPutLayout);
                panelOutPutLayout.setHorizontalGroup(
                        panelOutPutLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addComponent(jScrollPane4, javax.swing.GroupLayout.DEFAULT_SIZE, 715, Short.MAX_VALUE));
                panelOutPutLayout.setVerticalGroup(
                        panelOutPutLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addComponent(jScrollPane4, javax.swing.GroupLayout.DEFAULT_SIZE, 297, Short.MAX_VALUE));

                jTabbedPane1.addTab("Crear bit parcial", panelCargar);
                jTabbedPane1.setSelectedComponent(panelCargar);
            } else if (panel.getName().equals(panelErroresReconfiguracion)) {
                _TextErroresReconfiguracion.setColumns(20);
                _TextErroresReconfiguracion.setEditable(false);
                _TextErroresReconfiguracion.setRows(5);
                jScrollPane4.setViewportView(_TextErroresReconfiguracion);

                javax.swing.GroupLayout panelOutPutLayout = new javax.swing.GroupLayout(panelErroresReconfiguracion);
                panelErroresReconfiguracion.setLayout(panelOutPutLayout);
                panelOutPutLayout.setHorizontalGroup(
                        panelOutPutLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addComponent(jScrollPane4, javax.swing.GroupLayout.DEFAULT_SIZE, 715, Short.MAX_VALUE));
                panelOutPutLayout.setVerticalGroup(
                        panelOutPutLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addComponent(jScrollPane4, javax.swing.GroupLayout.DEFAULT_SIZE, 297, Short.MAX_VALUE));

                jTabbedPane1.addTab("OutPut", panelErroresReconfiguracion);
                jTabbedPane1.setSelectedComponent(panelErroresReconfiguracion);
            } else if (panel.getName().equals(panelTB)) {
                _TextTB.setColumns(20);
                _TextTB.setRows(5);
                _TextTB.setMaximumSize(getMaximumSize());
                jScrollPane2.setViewportView(_TextTB);

                javax.swing.GroupLayout panelCargarLayout = new javax.swing.GroupLayout(panelTB);
                panelTB.setLayout(panelCargarLayout);
                panelCargarLayout.setHorizontalGroup(
                        panelCargarLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addComponent(jScrollPane2, javax.swing.GroupLayout.DEFAULT_SIZE, 715, Short.MAX_VALUE));
                panelCargarLayout.setVerticalGroup(
                        panelCargarLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addComponent(jScrollPane2, javax.swing.GroupLayout.DEFAULT_SIZE, 297, Short.MAX_VALUE));

                jTabbedPane1.addTab("Cargar", panelTB);
                jTabbedPane1.setSelectedComponent(panelTB);
            } else if (panel.getName().equals(panelGolden)) {
                _TextGolden.setColumns(20);
                _TextGolden.setRows(5);
                jScrollPane3.setViewportView(_TextGolden);

                javax.swing.GroupLayout panelTBLayout = new javax.swing.GroupLayout(panelGolden);
                panelGolden.setLayout(panelTBLayout);
                panelTBLayout.setHorizontalGroup(
                        panelTBLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addComponent(jScrollPane3, javax.swing.GroupLayout.DEFAULT_SIZE, 715, Short.MAX_VALUE));
                panelTBLayout.setVerticalGroup(
                        panelTBLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addComponent(jScrollPane3, javax.swing.GroupLayout.DEFAULT_SIZE, 297, Short.MAX_VALUE));

                jTabbedPane1.addTab("Test Bench", panelGolden);
                jTabbedPane1.setSelectedComponent(panelGolden);
            } else {
                _TxtEntityVHD.setColumns(20);
                _TxtEntityVHD.setEditable(false);
                _TxtEntityVHD.setRows(5);
                jScrollPane1.setViewportView(_TxtEntityVHD);

                javax.swing.GroupLayout panelVHDLayout = new javax.swing.GroupLayout(panelVHD);
                panelVHD.setLayout(panelVHDLayout);
                panelVHDLayout.setHorizontalGroup(
                        panelVHDLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 699, Short.MAX_VALUE));
                panelVHDLayout.setVerticalGroup(
                        panelVHDLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 297, Short.MAX_VALUE));

                jTabbedPane1.addTab("Entity VHDL", panelVHD);
                jTabbedPane1.setSelectedComponent(panelVHD);

            }

        }
    } catch (Exception ex) {
//            Logger.getLogger(GUIPrincipal.class.getName()).log(Level.SEVERE, null, ex);
    }
}
    
    
private void configLog(String fichConf, boolean cargaFich) {
    Properties prop = new Properties();
    InputStream is;
    try {
        is = new FileInputStream(fichConf);
        prop.load(is);
        // Enumeration enume=prop.propertyNames();
        _TxtEntityVHD.setText(prop.getProperty("log4j.appender.LOGFILE.file"));
    } catch (IOException ioe) {
            JOptionPane.showMessageDialog(this, "No ha sido posible configurar" +
                    " nessy, debido a que no se ha encontrado archivo de " +
                    "configuración, para poder ejecutar Nessy correctamente" +
                    " acceda a configuración.", "Info", JOptionPane.INFORMATION_MESSAGE);
    }

}
private void initComponentsAux() {
    jTabbedPane1 = new JTabbedPaneWithCloseIcon();
}


public boolean configurarPuertoSerie(String com) {
    if (entsal != null) {
        entsal.cerrarPuertoSerie();
        entsal = null;
    }
    entsal = new EntradaSalida(com,tipoAdaptador);
    return entsal.inicializarPuertoSerie();
}
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    
    



    //////////////////////////////////////////////////////////////////////////
    /////////////////FUNCIONES PARA LA GESTIÓN DE PROYECTOS///////////////////
    //////////////////////////////////////////////////////////////////////////

private boolean proyectoNuevo(String rutaProyecto){
    boolean error = false;
    try {
        proyectoCerrar();
        
        RUTA_PROYECTO_ACTUAL = rutaProyecto;
        RUTA_PROYECTO_ACTUAL_EDK = RUTA_PROYECTO_ACTUAL + "\\edk";
        RUTA_PROYECTO_ACTUAL_PLANAHEAD = RUTA_PROYECTO_ACTUAL + "\\planahead";
        RUTA_PROYECTO_ACTUAL_SALIDAS = RUTA_PROYECTO_ACTUAL + "\\salidas";
        RUTA_PROYECTO_ACTUAL_VHDL = RUTA_PROYECTO_ACTUAL + "\\vhdl";
        //Crea la estructura del proyecto
        File directorio = new File(RUTA_PROYECTO_ACTUAL);
        directorio.mkdir();
        File directorio2 = new File(RUTA_PROYECTO_ACTUAL_EDK);
        directorio2.mkdir();
        File directorio3 = new File(RUTA_PROYECTO_ACTUAL_PLANAHEAD);
        directorio3.mkdir();
        File directorio4 = new File(RUTA_PROYECTO_ACTUAL_SALIDAS);
        directorio4.mkdir();
        File directorio5 = new File(RUTA_PROYECTO_ACTUAL_VHDL);
        directorio5.mkdir();
        File proyecto = new File(RUTA_PROYECTO_ACTUAL + "\\Proyecto.nessy");
        proyecto.createNewFile();
        deshabilitarBotones(true);
        return error;
    } catch (IOException ex) {
        Logger.getLogger(GUIPrincipal.class.getName()).log(Level.SEVERE, null, ex);
        error = true;
        return error;
    }
}

private boolean proyectoAbrir(String rutaProyecto) {
    boolean error = false;
    
    proyectoCerrar();

    RUTA_PROYECTO_ACTUAL = rutaProyecto;
    RUTA_PROYECTO_ACTUAL_EDK = RUTA_PROYECTO_ACTUAL + "\\edk";
    RUTA_PROYECTO_ACTUAL_PLANAHEAD = RUTA_PROYECTO_ACTUAL + "\\planahead";
    RUTA_PROYECTO_ACTUAL_SALIDAS = RUTA_PROYECTO_ACTUAL + "\\salidas";
    RUTA_PROYECTO_ACTUAL_VHDL = RUTA_PROYECTO_ACTUAL + "\\vhdl";

    deshabilitarBotones(true);
    _btnCargarVhd.setEnabled(true);
    _menuOpcionesCerrarProyecto.setEnabled(true);
    File proyecto = new File(RUTA_PROYECTO_ACTUAL + "\\Proyecto.nessy");
    try {
        BufferedReader br2 = new BufferedReader(new FileReader(RUTA_PROYECTO_ACTUAL + "\\Proyecto.nessy"));
        String s;
        //Leer la 1º línea, en caso de que exista, es que ya se han seleccionado los .vhd y hay un TOP
        s = br2.readLine();
        if (s != null) {
            //TOP
            ficheroEntidadVHD = RUTA_PROYECTO_ACTUAL_VHDL + "\\" + s;
            cargarVHDL();

            //Vhdls
            File vhdls = new File(RUTA_PROYECTO_ACTUAL_VHDL);
            String[] l = vhdls.list();
            stringsVHD.clear();
            stringsVHD.addAll(Arrays.asList(l));
            this.cargarVHDL();

            //Leer las 4 siguientes líneas, en caso de que exista el bitstream, contienen la información sobre los slices
            fichero_bit = new File(RUTA_PROYECTO_ACTUAL + "\\download.bit");
            fichero_bit_parcial = new File(RUTA_PROYECTO_ACTUAL + "\\config_nessy_circuito_0_circuito_reconfig_partial.bit_Clean.bit");
            //Si existe el bitstream completo, significa que también existe el parcial
            if (fichero_bit.exists()) {
                try {
                    sliceXInicial = Integer.parseInt(br2.readLine());
                    sliceYInicial = Integer.parseInt(br2.readLine());
                    sliceXFinal = Integer.parseInt(br2.readLine());
                    sliceYFinal = Integer.parseInt(br2.readLine());
                    tamSliceX = sliceXFinal - sliceXInicial;
                    tamSliceY = sliceYFinal - sliceYInicial;
                } catch (NumberFormatException e) {
                    tamSliceY = -1;
                    tamSliceX = -1;
                    sliceXInicial = -1;
                    sliceYInicial = -1;
                    proyecto.delete();
                    proyecto.createNewFile();
                    BufferedWriter bw = new BufferedWriter(new FileWriter(RUTA_PROYECTO_ACTUAL + "\\Proyecto.nessy"));
                    bw.write(s + "\n");
                    bw.close();
                }
                _btnCargarBit.setEnabled(true);
                //Comprobar que el proceso de síntesis no haya terminado mal y haya metainformación referente a las slices sin tener
                //generado el bitstream. Borra y crea el archivo .nessy con solo la información sobre el TOP
            } else if (br2.readLine() != null) {
                fichero_bit = null;
                fichero_bit_parcial = null;
                tamSliceY = -1;
                tamSliceX = -1;
                proyecto.delete();
                proyecto.createNewFile();
                BufferedWriter bw = new BufferedWriter(new FileWriter(RUTA_PROYECTO_ACTUAL + "\\Proyecto.nessy"));
                bw.write(s + "\n");
                bw.close();
            }

        }
        br2.close();
        
        _btnCrearBit.setEnabled(true);
        _comentariosProyecto.setText("Abierto el proyecto " + RUTA_PROYECTO_ACTUAL);
           
        return error;
    } catch (IOException ex) {
        deshabilitarBotones(true);
        error = true;
        return error;
    }
}

private void proyectoCerrar(){
    gestor.interrumpirHilos();
    _menuOpcionesCerrarProyecto.setEnabled(false);
    
    _btnCargarVhd.setEnabled(false);
    _btnCrearBit.setEnabled(false);
    _btnCargarBit.setEnabled(false);
    _btnCargarTB.setEnabled(false);
    _btnGenerarGolden.setEnabled(false);
    _btnCargarGolden.setEnabled(false);
    _btnEjecutar.setEnabled(false);
    _btnReconfiguracion.setEnabled(false);

    _TxtEntityVHD.setText("");
    _TextCrearBit.setText("");
    _TextCargarbit.setText("");
    _TextTB.setText("");
    _TextGolden.setText("");
    _TextEjecucion.setText("");
    _TextErroresReconfiguracion.setText("");
    _comentariosProyecto.setText("Ningun proyecto Nessy abierto");

    RUTA_PROYECTO_ACTUAL = null;
    RUTA_PROYECTO_ACTUAL_EDK = null;
    RUTA_PROYECTO_ACTUAL_PLANAHEAD = null;
    RUTA_PROYECTO_ACTUAL_SALIDAS = null;

    tamSliceX=0;
    tamSliceY=0;

    fichero_bit = null;
    fichero_bit_parcial = null;
    fichero_golden = null;
    fichero_tb = null;

    ficherosVHD = null;
    ficheroEntidadVHD = null;

    if(entsal!=null) entsal.cerrarPuertoSerie();
    entsal = null;
}


    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////
    
    
    
    
    
    ////////////////////////////////////////////////////////////////////////
    ////////////////////////CODIGO CREADO POR NETBEANS//////////////////////
    ///////////////////////////////////////////////////////////////////////
    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
    private void initComponents() {

        jPanel2 = new javax.swing.JPanel();
        jToolBar1 = new javax.swing.JToolBar();
        _btnCargarVhd = new javax.swing.JButton();
        _btnCrearBit = new javax.swing.JButton();
        _btnCargarBit = new javax.swing.JButton();
        _btnCargarTB = new javax.swing.JButton();
        _btnGenerarGolden = new javax.swing.JButton();
        _btnCargarGolden = new javax.swing.JButton();
        _btnEjecutar = new javax.swing.JButton();
        _btnReconfiguracion = new javax.swing.JButton();
        _chkParcialEnviado = new javax.swing.JCheckBox();
        jPanel1 = new javax.swing.JPanel();
        _btnClear = new javax.swing.JButton();
        jTabbedPane1 = new JTabbedPaneWithCloseIcon();
        panelVHD = new javax.swing.JPanel();
        jScrollPane1 = new javax.swing.JScrollPane();
        _TxtEntityVHD = new javax.swing.JTextArea();
        panelCrearBit = new javax.swing.JPanel();
        jScrollPane5 = new javax.swing.JScrollPane();
        _TextCrearBit = new javax.swing.JTextArea();
        panelCargar = new javax.swing.JPanel();
        jScrollPane7 = new javax.swing.JScrollPane();
        _TextCargarbit = new javax.swing.JTextArea();
        panelTB = new javax.swing.JPanel();
        jScrollPane2 = new javax.swing.JScrollPane();
        _TextTB = new javax.swing.JTextArea();
        panelGolden = new javax.swing.JPanel();
        jScrollPane3 = new javax.swing.JScrollPane();
        _TextGolden = new javax.swing.JTextArea();
        panelOutput = new javax.swing.JPanel();
        jScrollPane6 = new javax.swing.JScrollPane();
        _TextEjecucion = new javax.swing.JTextArea();
        panelErroresReconfiguracion = new javax.swing.JPanel();
        jScrollPane4 = new javax.swing.JScrollPane();
        _TextErroresReconfiguracion = new javax.swing.JTextArea();
        jSeparator1 = new javax.swing.JSeparator();
        _comentariosProyecto = new javax.swing.JLabel();
        jMenuBar1 = new javax.swing.JMenuBar();
        menuOpciones = new javax.swing.JMenu();
        _menuOpcionesNuevoProyecto = new javax.swing.JMenuItem();
        _menuOpcionesAbrirProyecto = new javax.swing.JMenuItem();
        _menuOpcionesCerrarProyecto = new javax.swing.JMenuItem();
        _menuOpcionesCerrarNessy = new javax.swing.JMenuItem();
        menuConfig = new javax.swing.JMenu();
        menuConfigNessy = new javax.swing.JMenuItem();
        menuConfigFichConf = new javax.swing.JMenuItem();
        menuConfigCom = new javax.swing.JMenuItem();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("Nessy 5.0 - Virtex V"); // NOI18N
        setIconImage(new ImageIcon("src/recursos/Nessy.png").getImage());
        setResizable(false);
        addWindowListener(new java.awt.event.WindowAdapter() {
            public void windowClosed(java.awt.event.WindowEvent evt) {
                formWindowClosed(evt);
            }
            public void windowClosing(java.awt.event.WindowEvent evt) {
                formWindowClosing(evt);
            }
        });

        jPanel2.setBorder(javax.swing.BorderFactory.createTitledBorder("Opciones"));
        jPanel2.setOpaque(false);

        jToolBar1.setRollover(true);

        _btnCargarVhd.setIcon(new javax.swing.ImageIcon(getClass().getResource("/recursos/btnCargarVhdl.png"))); // NOI18N
        _btnCargarVhd.setText("Cargar VHD"); // NOI18N
        _btnCargarVhd.setEnabled(false);
        _btnCargarVhd.setFocusable(false);
        _btnCargarVhd.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
        _btnCargarVhd.setVerticalTextPosition(javax.swing.SwingConstants.BOTTOM);
        _btnCargarVhd.setEnabled(false);
        _btnCargarVhd.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                _btnCargarVhdActionPerformed(evt);
            }
        });
        jToolBar1.add(_btnCargarVhd);

        _btnCrearBit.setIcon(new javax.swing.ImageIcon(getClass().getResource("/recursos/btnCrearBit.png"))); // NOI18N
        _btnCrearBit.setText("Crear bitstream"); // NOI18N
        _btnCrearBit.setEnabled(false);
        _btnCrearBit.setFocusable(false);
        _btnCrearBit.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
        _btnCrearBit.setVerticalTextPosition(javax.swing.SwingConstants.BOTTOM);
        _btnCrearBit.setEnabled(false);
        _btnCrearBit.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                _btnCrearBitActionPerformed(evt);
            }
        });
        jToolBar1.add(_btnCrearBit);

        _btnCargarBit.setIcon(new javax.swing.ImageIcon(getClass().getResource("/recursos/btnCargarBit.png"))); // NOI18N
        _btnCargarBit.setText("Cargar bitstream"); // NOI18N
        _btnCargarBit.setEnabled(false);
        _btnCargarBit.setFocusable(false);
        _btnCargarBit.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
        _btnCargarBit.setVerticalTextPosition(javax.swing.SwingConstants.BOTTOM);
        _btnCargarBit.setEnabled(false);
        _btnCargarBit.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                _btnCargarBitActionPerformed(evt);
            }
        });
        jToolBar1.add(_btnCargarBit);

        _btnCargarTB.setIcon(new javax.swing.ImageIcon(getClass().getResource("/recursos/btnCargarTB.png"))); // NOI18N
        _btnCargarTB.setText("Cargar Testbench"); // NOI18N
        _btnCargarTB.setEnabled(false);
        _btnCargarTB.setFocusable(false);
        _btnCargarTB.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
        _btnCargarTB.setVerticalTextPosition(javax.swing.SwingConstants.BOTTOM);
        _btnCargarTB.setEnabled(false);
        _btnCargarTB.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                _btnCargarTBActionPerformed(evt);
            }
        });
        jToolBar1.add(_btnCargarTB);

        _btnGenerarGolden.setIcon(new javax.swing.ImageIcon(getClass().getResource("/recursos/btnGeneraGolden.png"))); // NOI18N
        _btnGenerarGolden.setText("Generar golden"); // NOI18N
        _btnGenerarGolden.setEnabled(false);
        _btnGenerarGolden.setFocusable(false);
        _btnGenerarGolden.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
        _btnGenerarGolden.setVerticalTextPosition(javax.swing.SwingConstants.BOTTOM);
        _btnGenerarGolden.setEnabled(false);
        _btnGenerarGolden.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                _btnGenerarGoldenActionPerformed(evt);
            }
        });
        jToolBar1.add(_btnGenerarGolden);

        _btnCargarGolden.setIcon(new javax.swing.ImageIcon(getClass().getResource("/recursos/btnCargaGolden.jpg"))); // NOI18N
        _btnCargarGolden.setText("Cargar golden"); // NOI18N
        _btnCargarGolden.setEnabled(false);
        _btnCargarGolden.setFocusable(false);
        _btnCargarGolden.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
        _btnCargarGolden.setVerticalTextPosition(javax.swing.SwingConstants.BOTTOM);
        _btnCargarGolden.setEnabled(false);
        _btnCargarGolden.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                _btnCargarGoldenActionPerformed(evt);
            }
        });
        jToolBar1.add(_btnCargarGolden);

        _btnEjecutar.setIcon(new javax.swing.ImageIcon(getClass().getResource("/recursos/btnEjec.png"))); // NOI18N
        _btnEjecutar.setText("Ejecutar"); // NOI18N
        _btnEjecutar.setEnabled(false);
        _btnEjecutar.setFocusable(false);
        _btnEjecutar.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
        _btnEjecutar.setVerticalTextPosition(javax.swing.SwingConstants.BOTTOM);
        _btnEjecutar.setEnabled(false);
        _btnEjecutar.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                _btnEjecutarActionPerformed(evt);
            }
        });
        jToolBar1.add(_btnEjecutar);

        _btnReconfiguracion.setIcon(new javax.swing.ImageIcon(getClass().getResource("/recursos/reconParc.JPG"))); // NOI18N
        _btnReconfiguracion.setText("Reconfiguracion"); // NOI18N
        _btnReconfiguracion.setEnabled(false);
        _btnReconfiguracion.setEnabled(false);
        _btnReconfiguracion.setFocusable(false);
        _btnReconfiguracion.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
        _btnReconfiguracion.setVerticalTextPosition(javax.swing.SwingConstants.BOTTOM);
        _btnReconfiguracion.setEnabled(false);
        _btnReconfiguracion.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                _btnReconfiguracionActionPerformed(evt);
            }
        });
        jToolBar1.add(_btnReconfiguracion);

        _chkParcialEnviado.setText("Parcial enviado");
        _chkParcialEnviado.setFocusable(false);
        _chkParcialEnviado.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
        _chkParcialEnviado.setVerticalTextPosition(javax.swing.SwingConstants.BOTTOM);
        _chkParcialEnviado.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                _chkParcialEnviadoActionPerformed(evt);
            }
        });
        jToolBar1.add(_chkParcialEnviado);

        javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(jPanel2);
        jPanel2.setLayout(jPanel2Layout);
        jPanel2Layout.setHorizontalGroup(
            jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(jPanel2Layout.createSequentialGroup()
                .addComponent(jToolBar1, javax.swing.GroupLayout.PREFERRED_SIZE, 745, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addContainerGap(27, Short.MAX_VALUE))
        );
        jPanel2Layout.setVerticalGroup(
            jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(jPanel2Layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(jToolBar1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addContainerGap(53, Short.MAX_VALUE))
        );

        jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder("Pantalla"));
        jPanel1.setOpaque(false);

        _btnClear.setText("Limpiar Pantalla"); // NOI18N
        _btnClear.setAutoscrolls(true);
        _btnClear.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                _btnClearActionPerformed(evt);
            }
        });

        _TxtEntityVHD.setColumns(20);
        _TxtEntityVHD.setEditable(false);
        _TxtEntityVHD.setRows(5);
        jScrollPane1.setViewportView(_TxtEntityVHD);

        javax.swing.GroupLayout panelVHDLayout = new javax.swing.GroupLayout(panelVHD);
        panelVHD.setLayout(panelVHDLayout);
        panelVHDLayout.setHorizontalGroup(
            panelVHDLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(panelVHDLayout.createSequentialGroup()
                .addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 744, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
        );
        panelVHDLayout.setVerticalGroup(
            panelVHDLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 322, Short.MAX_VALUE)
        );

        jTabbedPane1.addTab("Entity VHDL", panelVHD);

        _TextCrearBit.setColumns(20);
        _TextCrearBit.setEditable(false);
        _TextCrearBit.setRows(5);
        jScrollPane5.setViewportView(_TextCrearBit);

        javax.swing.GroupLayout panelCrearBitLayout = new javax.swing.GroupLayout(panelCrearBit);
        panelCrearBit.setLayout(panelCrearBitLayout);
        panelCrearBitLayout.setHorizontalGroup(
            panelCrearBitLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jScrollPane5, javax.swing.GroupLayout.DEFAULT_SIZE, 747, Short.MAX_VALUE)
        );
        panelCrearBitLayout.setVerticalGroup(
            panelCrearBitLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jScrollPane5, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.DEFAULT_SIZE, 322, Short.MAX_VALUE)
        );

        jTabbedPane1.addTab("Crear .Bit", panelCrearBit);

        _TextCargarbit.setColumns(20);
        _TextCargarbit.setEditable(false);
        _TextCargarbit.setRows(5);
        jScrollPane7.setViewportView(_TextCargarbit);

        javax.swing.GroupLayout panelCargarLayout = new javax.swing.GroupLayout(panelCargar);
        panelCargar.setLayout(panelCargarLayout);
        panelCargarLayout.setHorizontalGroup(
            panelCargarLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jScrollPane7, javax.swing.GroupLayout.DEFAULT_SIZE, 747, Short.MAX_VALUE)
        );
        panelCargarLayout.setVerticalGroup(
            panelCargarLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jScrollPane7, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.DEFAULT_SIZE, 322, Short.MAX_VALUE)
        );

        jTabbedPane1.addTab("Cargar", panelCargar);

        _TextTB.setColumns(20);
        _TextTB.setRows(5);
        _TextTB.setMaximumSize(getMaximumSize());
        jScrollPane2.setViewportView(_TextTB);

        javax.swing.GroupLayout panelTBLayout = new javax.swing.GroupLayout(panelTB);
        panelTB.setLayout(panelTBLayout);
        panelTBLayout.setHorizontalGroup(
            panelTBLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jScrollPane2, javax.swing.GroupLayout.DEFAULT_SIZE, 747, Short.MAX_VALUE)
        );
        panelTBLayout.setVerticalGroup(
            panelTBLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jScrollPane2, javax.swing.GroupLayout.DEFAULT_SIZE, 322, Short.MAX_VALUE)
        );

        jTabbedPane1.addTab("Test Bench", panelTB);

        _TextGolden.setColumns(20);
        _TextGolden.setRows(5);
        jScrollPane3.setViewportView(_TextGolden);

        javax.swing.GroupLayout panelGoldenLayout = new javax.swing.GroupLayout(panelGolden);
        panelGolden.setLayout(panelGoldenLayout);
        panelGoldenLayout.setHorizontalGroup(
            panelGoldenLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jScrollPane3, javax.swing.GroupLayout.DEFAULT_SIZE, 747, Short.MAX_VALUE)
        );
        panelGoldenLayout.setVerticalGroup(
            panelGoldenLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jScrollPane3, javax.swing.GroupLayout.DEFAULT_SIZE, 322, Short.MAX_VALUE)
        );

        jTabbedPane1.addTab("Golden", panelGolden);

        _TextEjecucion.setColumns(20);
        _TextEjecucion.setEditable(false);
        _TextEjecucion.setRows(5);
        jScrollPane6.setViewportView(_TextEjecucion);

        javax.swing.GroupLayout panelOutputLayout = new javax.swing.GroupLayout(panelOutput);
        panelOutput.setLayout(panelOutputLayout);
        panelOutputLayout.setHorizontalGroup(
            panelOutputLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jScrollPane6, javax.swing.GroupLayout.DEFAULT_SIZE, 747, Short.MAX_VALUE)
        );
        panelOutputLayout.setVerticalGroup(
            panelOutputLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jScrollPane6, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.DEFAULT_SIZE, 322, Short.MAX_VALUE)
        );

        jTabbedPane1.addTab("Output", panelOutput);

        _TextErroresReconfiguracion.setColumns(20);
        _TextErroresReconfiguracion.setEditable(false);
        _TextErroresReconfiguracion.setRows(5);
        jScrollPane4.setViewportView(_TextErroresReconfiguracion);

        javax.swing.GroupLayout panelErroresReconfiguracionLayout = new javax.swing.GroupLayout(panelErroresReconfiguracion);
        panelErroresReconfiguracion.setLayout(panelErroresReconfiguracionLayout);
        panelErroresReconfiguracionLayout.setHorizontalGroup(
            panelErroresReconfiguracionLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jScrollPane4, javax.swing.GroupLayout.DEFAULT_SIZE, 747, Short.MAX_VALUE)
        );
        panelErroresReconfiguracionLayout.setVerticalGroup(
            panelErroresReconfiguracionLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jScrollPane4, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.DEFAULT_SIZE, 322, Short.MAX_VALUE)
        );

        jTabbedPane1.addTab("Reconfiguraci\u00f3n", panelErroresReconfiguracion);

        javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
        jPanel1.setLayout(jPanel1Layout);
        jPanel1Layout.setHorizontalGroup(
            jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanel1Layout.createSequentialGroup()
                .addContainerGap(488, Short.MAX_VALUE)
                .addComponent(_btnClear, javax.swing.GroupLayout.PREFERRED_SIZE, 190, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(94, 94, 94))
            .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                .addGroup(jPanel1Layout.createSequentialGroup()
                    .addContainerGap()
                    .addComponent(jTabbedPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 752, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))
        );
        jPanel1Layout.setVerticalGroup(
            jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(jPanel1Layout.createSequentialGroup()
                .addGap(19, 19, 19)
                .addComponent(_btnClear)
                .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
            .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                .addGroup(jPanel1Layout.createSequentialGroup()
                    .addGap(40, 40, 40)
                    .addComponent(jTabbedPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 350, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addContainerGap(57, Short.MAX_VALUE)))
        );

        jTabbedPane1.getAccessibleContext().setAccessibleName(""); // NOI18N

        _comentariosProyecto.setFont(new java.awt.Font("Tahoma", 1, 14)); // NOI18N
        _comentariosProyecto.setText("Ningun proyecto Nessy abierto");

        menuOpciones.setText("Archivo"); // NOI18N
        menuOpciones.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                menuOpcionesActionPerformed(evt);
            }
        });

        _menuOpcionesNuevoProyecto.setAccelerator(javax.swing.KeyStroke.getKeyStroke(java.awt.event.KeyEvent.VK_N, java.awt.event.InputEvent.CTRL_MASK));
        _menuOpcionesNuevoProyecto.setText("Nuevo Proyecto"); // NOI18N
        _menuOpcionesNuevoProyecto.setEnabled(true);
        _menuOpcionesNuevoProyecto.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                _menuOpcionesNuevoProyectoActionPerformed(evt);
            }
        });
        menuOpciones.add(_menuOpcionesNuevoProyecto);

        _menuOpcionesAbrirProyecto.setAccelerator(javax.swing.KeyStroke.getKeyStroke(java.awt.event.KeyEvent.VK_A, java.awt.event.InputEvent.CTRL_MASK));
        _menuOpcionesAbrirProyecto.setText("Abrir Proyecto"); // NOI18N
        _menuOpcionesAbrirProyecto.setEnabled(true);
        _menuOpcionesAbrirProyecto.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                _menuOpcionesAbrirProyectoActionPerformed(evt);
            }
        });
        menuOpciones.add(_menuOpcionesAbrirProyecto);

        _menuOpcionesCerrarProyecto.setAccelerator(javax.swing.KeyStroke.getKeyStroke(java.awt.event.KeyEvent.VK_C, java.awt.event.InputEvent.CTRL_MASK));
        _menuOpcionesCerrarProyecto.setText("Cerrar Proyecto"); // NOI18N
        _menuOpcionesCerrarProyecto.setEnabled(false);
        _menuOpcionesCerrarProyecto.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                _menuOpcionesCerrarProyectoActionPerformed(evt);
            }
        });
        menuOpciones.add(_menuOpcionesCerrarProyecto);

        _menuOpcionesCerrarNessy.setAccelerator(javax.swing.KeyStroke.getKeyStroke(java.awt.event.KeyEvent.VK_ESCAPE, 0));
        _menuOpcionesCerrarNessy.setText("Cerrar Nessy"); // NOI18N
        _menuOpcionesCerrarNessy.setEnabled(true);
        _menuOpcionesCerrarNessy.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                _menuOpcionesCerrarNessyActionPerformed(evt);
            }
        });
        menuOpciones.add(_menuOpcionesCerrarNessy);

        jMenuBar1.add(menuOpciones);

        menuConfig.setText("Configuración"); // NOI18N
        menuConfig.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                menuConfigActionPerformed(evt);
            }
        });

        menuConfigNessy.setText("Configurar Nessy"); // NOI18N
        menuConfigNessy.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                menuConfigNessyActionPerformed(evt);
            }
        });
        menuConfig.add(menuConfigNessy);

        menuConfigFichConf.setText("Cargar Fichero Configuración"); // NOI18N
        menuConfigFichConf.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                menuConfigFichConfActionPerformed(evt);
            }
        });
        menuConfig.add(menuConfigFichConf);

        menuConfigCom.setText("Configurar puerto serie");
        menuConfigCom.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                menuConfigComActionPerformed(evt);
            }
        });
        menuConfig.add(menuConfigCom);

        jMenuBar1.add(menuConfig);

        setJMenuBar(jMenuBar1);

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addGroup(layout.createSequentialGroup()
                        .addComponent(jSeparator1, javax.swing.GroupLayout.DEFAULT_SIZE, 1, Short.MAX_VALUE)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
                            .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                            .addComponent(jPanel2, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))
                    .addGroup(layout.createSequentialGroup()
                        .addGap(10, 10, 10)
                        .addComponent(_comentariosProyecto, javax.swing.GroupLayout.PREFERRED_SIZE, 770, javax.swing.GroupLayout.PREFERRED_SIZE)))
                .addContainerGap())
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
                    .addGroup(javax.swing.GroupLayout.Alignment.LEADING, layout.createSequentialGroup()
                        .addGap(147, 147, 147)
                        .addComponent(jSeparator1, javax.swing.GroupLayout.PREFERRED_SIZE, 10, javax.swing.GroupLayout.PREFERRED_SIZE))
                    .addGroup(layout.createSequentialGroup()
                        .addContainerGap()
                        .addComponent(_comentariosProyecto, javax.swing.GroupLayout.PREFERRED_SIZE, 24, javax.swing.GroupLayout.PREFERRED_SIZE)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                        .addComponent(jPanel2, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)))
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
                .addComponent(jPanel1, javax.swing.GroupLayout.PREFERRED_SIZE, 414, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(37, 37, 37))
        );

        pack();
    }// </editor-fold>//GEN-END:initComponents

    private void _btnCargarVhdActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event__btnCargarVhdActionPerformed
        Seleccion sel = new Seleccion();
        GUICargaVHDL guiVhdl = new GUICargaVHDL(this, true, sel);
        guiVhdl.setLocationRelativeTo(null);
        guiVhdl.setVisible(true);
        if (sel.seleccion.equals(SeleccionCargaVHD.SELECCION_VHDL_TOP)) {
            cargaTopVHDL();
            _btnCrearBit.setEnabled(true);
        } else {
            if (sel.seleccion.equals(SeleccionCargaVHD.SELECCION_VARIOS_VHDL)) {
                cargaVariosVHDL();
                _btnCrearBit.setEnabled(true);
            }
        }
        try {
            File dirVhdl = new File(RUTA_PROYECTO_ACTUAL_VHDL);
            File[] listaArchivos = dirVhdl.listFiles();
            for (int i = 0; i < listaArchivos.length; i++) {
                listaArchivos[i].delete();
            }
            for (int i = 0; i < ficherosVHD.size(); i++) {
                Process proc_archivo = Runtime.getRuntime().exec("xcopy /Y /Q \"" + ficherosVHD.get(i) + "\" \"" + RUTA_PROYECTO_ACTUAL_VHDL + "\"");
                proc_archivo.waitFor();
            }
            stringsVHD.clear();
            for (int i = 0; i < ficherosVHD.size(); i++) {
                stringsVHD.add(ficherosVHD.get(i).getName());
            }
            BufferedWriter bw2 = new BufferedWriter(new FileWriter(RUTA_PROYECTO_ACTUAL + "\\Proyecto.nessy"));
            if (ficherosVHD.size() > 1) {
                bw2.write(ficherosVHD.get(top).getName() + "\n");
            } else {
                bw2.write(ficherosVHD.get(0).getName() + "\n");
            }
            bw2.close();
        } catch (InterruptedException ex) {
            Logger.getLogger(GUIPrincipal.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(GUIPrincipal.class.getName()).log(Level.SEVERE, null, ex);
        }
    }//GEN-LAST:event__btnCargarVhdActionPerformed

    private void _btnCargarBitActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event__btnCargarBitActionPerformed
        try {
            if(entsal != null){
                entsal.cerrarPuertoSerie();
                entsal = null;
            }
            
            //Deshabilita las acciones posteriores a cargar bitstream
            _btnCargarTB.setEnabled(false);
            _btnCargarGolden.setEnabled(false);
            _btnGenerarGolden.setEnabled(false);
            _btnEjecutar.setEnabled(false);
            _btnReconfiguracion.setEnabled(false);
            //Comprueba que exista el bitstream para poder programar la FPGA
            fichero_bit = new File(GUIPrincipal.RUTA_PROYECTO_ACTUAL+"\\download.bit");
            String comando = "java -jar "+GUIPrincipal.RUTA_NESSY+"\\Virtex_V_Configuration_Cleaner.jar -i " + GUIPrincipal.RUTA_PROYECTO_ACTUAL+"\\config_nessy_circuito_0_circuito_reconfig_partial.bit";
            Process proc_parcial = Runtime.getRuntime().exec(comando);
            proc_parcial.waitFor();
            fichero_bit_parcial = new File(RUTA_PROYECTO_ACTUAL + "\\config_nessy_circuito_0_circuito_reconfig_partial.bit_Clean.bit");
            if (fichero_bit.exists()) {
                //USA PROCESOS EXTERNOS
                if (!this.cargarBit(fichero_bit.toString())) {
                    JOptionPane.showMessageDialog(this, "No se ha podido Cargar el bitstream correctamente", "Error", JOptionPane.ERROR_MESSAGE);
                }
            } else {
                JOptionPane.showMessageDialog(this, "El bitstream no ha sido generado aún", "Información", JOptionPane.INFORMATION_MESSAGE);
            }
        } catch (IOException ex) {
            Logger.getLogger(GUIPrincipal.class.getName()).log(Level.SEVERE, null, ex);
        } catch (InterruptedException ex){
            Logger.getLogger(GUIPrincipal.class.getName()).log(Level.SEVERE, null, ex);
        }
    }//GEN-LAST:event__btnCargarBitActionPerformed

    private void _btnEjecutarActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event__btnEjecutarActionPerformed
        try {
            if (!ejecutar()) {
                JOptionPane.showMessageDialog(this, "Error en la ejecución del testbench", "Error", JOptionPane.ERROR_MESSAGE);
            }
        } catch (Exception ex) {
            Logger.getLogger(GUIPrincipal.class.getName()).log(Level.SEVERE, null, ex);
        }
    }//GEN-LAST:event__btnEjecutarActionPerformed

    private void _btnCargarTBActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event__btnCargarTBActionPerformed

        //Deshabilita las acciones posteriores a cargar testbench
        _btnCargarGolden.setEnabled(false);
        _btnGenerarGolden.setEnabled(false);
        _btnEjecutar.setEnabled(false);
        _btnReconfiguracion.setEnabled(false);
        if (this.cargarTB()) {
            _btnCargarGolden.setEnabled(true);
            _btnGenerarGolden.setEnabled(true);
        }
    }//GEN-LAST:event__btnCargarTBActionPerformed

    private void _btnClearActionPerformed(java.awt.event.ActionEvent evt) {

        if (jTabbedPane1.getComponentCount() > 0) {
            javax.swing.JPanel panel = (javax.swing.JPanel) jTabbedPane1.getSelectedComponent();
            javax.swing.JScrollPane scrPanel = (javax.swing.JScrollPane) panel.getComponent(0);
            javax.swing.JViewport viewPort = (javax.swing.JViewport) scrPanel.getComponent(0);
            javax.swing.JTextArea txtArea = (javax.swing.JTextArea) viewPort.getComponent(0);
            txtArea.setText("");
        }
    }

    private void formWindowClosed(java.awt.event.WindowEvent evt) {//GEN-FIRST:event_formWindowClosed

    }//GEN-LAST:event_formWindowClosed

private void _btnGenerarGoldenActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event__btnGenerarGoldenActionPerformed
    //Deshabilita las acciones posteriores a generar golden
    _btnEjecutar.setEnabled(false);
    _btnReconfiguracion.setEnabled(false);
    if (this.generarGolden()) {
        _btnEjecutar.setEnabled(true);
        _btnReconfiguracion.setEnabled(true);
    } else {
        JOptionPane.showMessageDialog(this, "No se ha podido generar el golden correctamente", "Error", JOptionPane.ERROR_MESSAGE);
    }
}//GEN-LAST:event__btnGenerarGoldenActionPerformed

private void _btnCargarGoldenActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event__btnCargarGoldenActionPerformed
    _btnEjecutar.setEnabled(false);
    _btnReconfiguracion.setEnabled(false);
    if (this.cargarGolden()) {
        _btnEjecutar.setEnabled(true);
        _btnReconfiguracion.setEnabled(true);
    } else {
        JOptionPane.showMessageDialog(this, "No se ha podido cargar el golden correctamente", "Error", JOptionPane.ERROR_MESSAGE);
    }
}//GEN-LAST:event__btnCargarGoldenActionPerformed

private void menuConfigNessyActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_menuConfigNessyActionPerformed
        String rutaISE = "";
        String rutaEDK = "";
        String rutaPlanAhead = "";
        if (RUTA_ISE != null) {
            rutaISE = RUTA_ISE;
        }
        if (RUTA_EDK != null) {
            rutaEDK = RUTA_EDK;
        }
        if (RUTA_PLANAHEAD != null) {
            rutaPlanAhead = RUTA_PLANAHEAD;
        }
        GUIConfig config = new GUIConfig(this, true, rutaISE, rutaEDK, rutaPlanAhead);
        config.setVisible(true);
        try {
            InputStream is;
            Properties prop = new Properties();
            is = new FileInputStream(RUTA_NESSY+"\\conf\\config.properties");
            prop.load(is);
            RUTA_ISE = prop.getProperty("HomeXilinxISE");
            RUTA_EDK = prop.getProperty("HomeXilinxEDK");
            RUTA_PLANAHEAD = prop.getProperty("HomeXilinxPLANAHEAD");
        } catch (IOException ex) {
            Logger.getLogger(GUIPrincipal.class.getName()).log(Level.SEVERE, null, ex);
        }
}//GEN-LAST:event_menuConfigNessyActionPerformed

private void menuConfigFichConfActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_menuConfigFichConfActionPerformed

    JFileChooser chooser;
    chooser = new JFileChooser();
    Filtro filter = new Filtro("properties");
    chooser.addChoosableFileFilter(filter);
    chooser.setCurrentDirectory(new java.io.File("."));
    chooser.setDialogTitle("Seleccionar Archivo Configuración");
    chooser.setAcceptAllFileFilterUsed(false);
    chooser.setMultiSelectionEnabled(false);
    ficherosVHD = new ArrayList<>();
    if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
        configurarNessy(chooser.getSelectedFile().getAbsolutePath(), true);

    }

}//GEN-LAST:event_menuConfigFichConfActionPerformed

private void _btnReconfiguracionActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event__btnReconfiguracionActionPerformed
    try {
        if (!reconfiguracion()) {
            JOptionPane.showMessageDialog(this, "Error al inyectar errores" , "Error", JOptionPane.ERROR_MESSAGE);
        }
    } catch (Exception ex) {
        java.util.logging.Logger.getLogger(GUIPrincipal.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
    }
}//GEN-LAST:event__btnReconfiguracionActionPerformed

private void formWindowClosing(java.awt.event.WindowEvent evt) {//GEN-FIRST:event_formWindowClosing

}//GEN-LAST:event_formWindowClosing

private void _btnCrearBitActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event__btnCrearBitActionPerformed
    try {
        //Deshabilita las acciones posteriores a generar bitstream
        _btnCargarBit.setEnabled(false);
        _btnCargarTB.setEnabled(false);
        _btnCargarGolden.setEnabled(false);
        _btnGenerarGolden.setEnabled(false);
        _btnEjecutar.setEnabled(false);
        _btnReconfiguracion.setEnabled(false);
        //USA PROCESOS EXTERNOS
        if (!this.crearBit()) {
            JOptionPane.showMessageDialog(this, "No se ha podido generar el .bit correctamente", "Error", JOptionPane.ERROR_MESSAGE);
        }
    } catch (Exception ex) {
        Logger.getLogger(GUIPrincipal.class.getName()).log(Level.SEVERE, null, ex);
    }
}//GEN-LAST:event__btnCrearBitActionPerformed

private void _menuOpcionesCerrarNessyActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event__menuOpcionesCerrarNessyActionPerformed
    System.exit(0);
}//GEN-LAST:event__menuOpcionesCerrarNessyActionPerformed

private void _menuOpcionesCerrarProyectoActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event__menuOpcionesCerrarProyectoActionPerformed
    proyectoCerrar();
}//GEN-LAST:event__menuOpcionesCerrarProyectoActionPerformed

private void _menuOpcionesAbrirProyectoActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event__menuOpcionesAbrirProyectoActionPerformed
    JFileChooser chooser;
    String rutaProyecto;
    boolean error;
    
    chooser = new JFileChooser();
    chooser.setCurrentDirectory(new java.io.File("."));
    chooser.setDialogTitle("Selecciona el proyecto Nessy que desea abrir");
    chooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
    chooser.setFileFilter(new FileNameExtensionFilter("Proyectos nessy (.nessy)","nessy"));
    chooser.setAcceptAllFileFilterUsed(false);
    if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION){
       rutaProyecto = chooser.getSelectedFile().getParent();
       proyectoAbrir(rutaProyecto);
    }
}//GEN-LAST:event__menuOpcionesAbrirProyectoActionPerformed

private void _menuOpcionesNuevoProyectoActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event__menuOpcionesNuevoProyectoActionPerformed
    String sel="";
    String rutaProyecto;
    boolean error;
    GUINuevoProyecto GuiProyecto = new GUINuevoProyecto(this, true,sel);
    GuiProyecto.setLocationRelativeTo(null);
    GuiProyecto.setVisible(true);
    if (GuiProyecto.getSeleccion().equals("ok")) {

        rutaProyecto = GuiProyecto.getDirectorio() + "\\" + GuiProyecto.getNombreProyecto();
        error = proyectoNuevo(rutaProyecto);
        if(!error){
            _btnCargarVhd.setEnabled(true);
            _menuOpcionesCerrarProyecto.setEnabled(true);
            _comentariosProyecto.setText("Abierto el proyecto " + RUTA_PROYECTO_ACTUAL);
        }
    }

}//GEN-LAST:event__menuOpcionesNuevoProyectoActionPerformed


private void menuConfigComActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_menuConfigComActionPerformed
    boolean ret = true;
    GUIComConfig GUIcom = new GUIComConfig(this, ret);
    GUIcom.setLocationRelativeTo(null);
    GUIcom.setVisible(true);
    
    ret = configurarPuertoSerie(GUIcom.getSel());
    if (!ret) {
        JOptionPane.showMessageDialog(this, "Error al abrir el puerto " + GUIcom.getSel(), "Error", JOptionPane.ERROR_MESSAGE);
        entsal = null;
    }
}//GEN-LAST:event_menuConfigComActionPerformed

private void menuConfigActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_menuConfigActionPerformed
    // TODO add your handling code here:
}//GEN-LAST:event_menuConfigActionPerformed

private void menuOpcionesActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_menuOpcionesActionPerformed
    // TODO add your handling code here:
}//GEN-LAST:event_menuOpcionesActionPerformed

private void _chkParcialEnviadoActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event__chkParcialEnviadoActionPerformed
    if(_chkParcialEnviado.isSelected()) parcialEnviado = true;
    else parcialEnviado = false;
}//GEN-LAST:event__chkParcialEnviadoActionPerformed

    // Variables declaration - do not modify//GEN-BEGIN:variables
    private javax.swing.JTextArea _TextCargarbit;
    private javax.swing.JTextArea _TextCrearBit;
    private javax.swing.JTextArea _TextEjecucion;
    private javax.swing.JTextArea _TextErroresReconfiguracion;
    private javax.swing.JTextArea _TextGolden;
    private javax.swing.JTextArea _TextTB;
    private javax.swing.JTextArea _TxtEntityVHD;
    private javax.swing.JButton _btnCargarBit;
    private javax.swing.JButton _btnCargarGolden;
    private javax.swing.JButton _btnCargarTB;
    private javax.swing.JButton _btnCargarVhd;
    private javax.swing.JButton _btnClear;
    private javax.swing.JButton _btnCrearBit;
    private javax.swing.JButton _btnEjecutar;
    private javax.swing.JButton _btnGenerarGolden;
    private javax.swing.JButton _btnReconfiguracion;
    private javax.swing.JCheckBox _chkParcialEnviado;
    private javax.swing.JLabel _comentariosProyecto;
    private javax.swing.JMenuItem _menuOpcionesAbrirProyecto;
    private javax.swing.JMenuItem _menuOpcionesCerrarNessy;
    private javax.swing.JMenuItem _menuOpcionesCerrarProyecto;
    private javax.swing.JMenuItem _menuOpcionesNuevoProyecto;
    private javax.swing.JMenuBar jMenuBar1;
    private javax.swing.JPanel jPanel1;
    private javax.swing.JPanel jPanel2;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JScrollPane jScrollPane2;
    private javax.swing.JScrollPane jScrollPane3;
    private javax.swing.JScrollPane jScrollPane4;
    private javax.swing.JScrollPane jScrollPane5;
    private javax.swing.JScrollPane jScrollPane6;
    private javax.swing.JScrollPane jScrollPane7;
    private javax.swing.JSeparator jSeparator1;
    private javax.swing.JTabbedPane jTabbedPane1;
    private javax.swing.JToolBar jToolBar1;
    private javax.swing.JMenu menuConfig;
    private javax.swing.JMenuItem menuConfigCom;
    private javax.swing.JMenuItem menuConfigFichConf;
    private javax.swing.JMenuItem menuConfigNessy;
    private javax.swing.JMenu menuOpciones;
    private javax.swing.JPanel panelCargar;
    private javax.swing.JPanel panelCrearBit;
    private javax.swing.JPanel panelErroresReconfiguracion;
    private javax.swing.JPanel panelGolden;
    private javax.swing.JPanel panelOutput;
    private javax.swing.JPanel panelTB;
    private javax.swing.JPanel panelVHD;
    // End of variables declaration//GEN-END:variables


}
